package com.qinghe.utils.excel;

import java.io.IOException;
import java.io.InputStream;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;

import org.apache.commons.lang3.StringUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;

/**
 * Excel解析
 * 
 * @author longfei
 */
public class ExcelImport {

	protected Object[] objs;// 数据模型

	private int sheetIndex;// 需要读取的excel中sheet下标值

	private Workbook wb;// 解析excel工作表对象

	private Sheet sheet;// 工作表

	private Row row;// 行对象

	private static String dateFormatType = "";

	private static DecimalFormat df = new DecimalFormat("#.##");

	public void builExcel(InputStream inputStream) throws IOException {
		wb = new HSSFWorkbook(inputStream);
	}

	public void setSheetIndex(int sheetIndex) {
		this.sheetIndex = sheetIndex;
	}

	/**
	 * 查询单个工作薄的标题栏
	 * 
	 * @param startRow 起始行（从0开始）
	 * @return Object[]
	 */
	public Object[] getSheetCellTitle(int startRow) {
		sheet = wb.getSheetAt(sheetIndex);
		// 获取第startRow行的总列数
		int cellIndex = sheet.getRow(startRow).getPhysicalNumberOfCells();
		// 获取单元格
		row = sheet.getRow(startRow);
		if (null != row) {
			objs = new Object[cellIndex];
			for (int i = 0; i < cellIndex; i++) {
				objs[i] = getCellValue(row, i);
			}
		}
		return objs;
	}

	/**
	 * 查询单个工作薄
	 * 
	 * @param startRow 起始行（从0开始）
	 * @param startCell 去掉第x列数据（从1开始）
	 * @param titleRow 标题栏行
	 * @return ArrayList<Object[]>
	 */
	public ArrayList<Object[]> getSheetCellValue(int startRow, int startCell, int titleRow) {
		dateFormatType = "";
		ArrayList<Object[]> resultList = new ArrayList<Object[]>();
		sheet = wb.getSheetAt(sheetIndex);
		String value = "";
		// 获取总行数
		int rowIndex = sheet.getPhysicalNumberOfRows();
		// 获取标题行的总列数
		int cellIndex = sheet.getRow(titleRow).getPhysicalNumberOfCells();

		for (int i = startRow; i < rowIndex; i++) {
			// 获取单元格
			row = sheet.getRow(i);
			if (null != row) {
				objs = new Object[cellIndex - startCell];
				// 整行记录是否为空标识
				boolean isExist = true;
				for (int j = startCell; j < cellIndex; j++) {
					value = getCellValue(row, j);
					objs[j - startCell] = value;
					if (isExist) {
						isExist = StringUtils.isBlank(value);
					}
				}
				// 整行记录中所有单元格有一个不是空,该行获取
				if (!isExist) {
					resultList.add(objs);
				}
				objs = null;
			} else {
				rowIndex++;
			}
		}
		return resultList;
	}

	/**
	 * 查询多个工作薄中的值
	 * 
	 * @param startRow 起始行（从0开始）
	 * @param startCell 去掉第x列数据（从1开始）
	 * @return ArrayList<ArrayList<Object[]>>
	 */
	public ArrayList<ArrayList<Object[]>> getMuiltSheetCellValue(Integer[] startRow, Integer[] startCell) {
		dateFormatType = "";
		boolean flag = false;
		// 保存表集合
		ArrayList<ArrayList<Object[]>> tables = new ArrayList<ArrayList<Object[]>>();
		// 保存行集合
		ArrayList<Object[]> rows = null;
		// 单元格中的值
		String value = "";
		// 行中有值的单元格总数量
		int cellTotalNum = 0;

		// 获得多个工作薄
		for (int numSheet = 0; numSheet < wb.getNumberOfSheets(); numSheet++) {
			rows = new ArrayList<Object[]>();
			// 获取其中一个工作薄
			sheet = wb.getSheetAt(numSheet);
			// 读取单个工作薄中的行
			for (int numRow = startRow[numSheet]; numRow <= sheet.getLastRowNum(); numRow++) {
				row = sheet.getRow(numRow);
				if (null != row) {
					cellTotalNum = row.getLastCellNum();
					objs = new Object[cellTotalNum - startCell[numSheet]];
					// 读取行中单元格的值
					for (int numCell = startCell[numSheet]; numCell <= cellTotalNum; numCell++) {
						value = getCellValue(row, numCell);
						if (null != value && !"".equals(value)) {
							objs[numCell - startCell[numSheet]] = value;
							flag = true;
						}
					}
					if (flag) {
						rows.add(objs);
					}
					objs = null;
					flag = false;
				}
			}
			if (rows.size() > 0)
				tables.add(rows);
			rows = null;
		}
		return tables;
	}

	/**
	 * 获取获取单元格值
	 * 
	 * @param row excel行对象
	 * @param index excel单元格的位置
	 * @return 返回获取单元格值
	 */
	protected static String getCellValue(Row row, int index) {
		return getCellValue(row, index, Integer.MAX_VALUE);
	}

	/**
	 * 获取获取单元格值
	 * 
	 * @param row excel行对象
	 * @param index excel单元格的位置
	 * @param maxLength单元格值最大长度
	 * @return 返回获取单元格值
	 */
	protected static String getCellValue(Row row, int index, int maxLength) {
		return getCellValue(row.getCell((short) index), maxLength);
	}

	/**
	 * 获取获取单元格值
	 * 
	 * @param cell 单元格对象
	 * @param maxLength 单元格值最大长度
	 * @return 返回获取单元格值
	 */
	protected static String getCellValue(Cell cell, int maxLength) {
		String value = "";
		if (cell != null) {
			switch (cell.getCellType()) {
			case Cell.CELL_TYPE_STRING:
				value = cell.getStringCellValue();
				break;
			case Cell.CELL_TYPE_NUMERIC:
				if (DateUtil.isCellDateFormatted(cell)) {
					DateFormat sdf = null;
					if (StringUtils.isBlank(dateFormatType)) {
						sdf = new SimpleDateFormat("yyyy-MM-dd");
					} else {
						sdf = new SimpleDateFormat(dateFormatType);
					}
					value = sdf.format(cell.getDateCellValue());
				} else {
					value = df.format(cell.getNumericCellValue());
				}
				break;
			case Cell.CELL_TYPE_BOOLEAN:
				value = String.valueOf(cell.getBooleanCellValue());
				break;
			default:
				value = cell.getStringCellValue();
				break;
			}
		}
		value = value.trim();
		return value.substring(0, maxLength > value.length() ? value.length() : maxLength);
	}

}
